353 research outputs found
Practical Sparse Matrices in C++ with Hybrid Storage and Template-Based Expression Optimisation
Despite the importance of sparse matrices in numerous fields of science,
software implementations remain difficult to use for non-expert users,
generally requiring the understanding of underlying details of the chosen
sparse matrix storage format. In addition, to achieve good performance, several
formats may need to be used in one program, requiring explicit selection and
conversion between the formats. This can be both tedious and error-prone,
especially for non-expert users. Motivated by these issues, we present a
user-friendly and open-source sparse matrix class for the C++ language, with a
high-level application programming interface deliberately similar to the widely
used MATLAB language. This facilitates prototyping directly in C++ and aids the
conversion of research code into production environments. The class internally
uses two main approaches to achieve efficient execution: (i) a hybrid storage
framework, which automatically and seamlessly switches between three underlying
storage formats (compressed sparse column, Red-Black tree, coordinate list)
depending on which format is best suited and/or available for specific
operations, and (ii) a template-based meta-programming framework to
automatically detect and optimise execution of common expression patterns.
Empirical evaluations on large sparse matrices with various densities of
non-zero elements demonstrate the advantages of the hybrid storage framework
and the expression optimisation mechanism.Comment: extended and revised version of an earlier conference paper
arXiv:1805.0338
An Open Source C++ Implementation of Multi-Threaded Gaussian Mixture Models, k-Means and Expectation Maximisation
Modelling of multivariate densities is a core component in many signal
processing, pattern recognition and machine learning applications. The
modelling is often done via Gaussian mixture models (GMMs), which use
computationally expensive and potentially unstable training algorithms. We
provide an overview of a fast and robust implementation of GMMs in the C++
language, employing multi-threaded versions of the Expectation Maximisation
(EM) and k-means training algorithms. Multi-threading is achieved through
reformulation of the EM and k-means algorithms into a MapReduce-like framework.
Furthermore, the implementation uses several techniques to improve numerical
stability and modelling accuracy. We demonstrate that the multi-threaded
implementation achieves a speedup of an order of magnitude on a recent 16 core
machine, and that it can achieve higher modelling accuracy than a previously
well-established publically accessible implementation. The multi-threaded
implementation is included as a user-friendly class in recent releases of the
open source Armadillo C++ linear algebra library. The library is provided under
the permissive Apache~2.0 license, allowing unencumbered use in commercial
products
An Adaptive Solver for Systems of Linear Equations
Computational implementations for solving systems of linear equations often
rely on a one-size-fits-all approach based on LU decomposition of dense
matrices stored in column-major format. Such solvers are typically implemented
with the aid of the xGESV set of functions available in the low-level LAPACK
software, with the aim of reducing development time by taking advantage of
well-tested routines. However, this straightforward approach does not take into
account various matrix properties which can be exploited to reduce the
computational effort and/or to increase numerical stability. Furthermore,
direct use of LAPACK functions can be error-prone for non-expert users and
results in source code that has little resemblance to originating mathematical
expressions. We describe an adaptive solver that we have implemented inside
recent versions of the high-level Armadillo C++ library for linear algebra. The
solver automatically detects several common properties of a given system
(banded, triangular, symmetric positive definite), followed by solving the
system via mapping to a set of suitable LAPACK functions best matched to each
property. The solver also detects poorly conditioned systems and automatically
seeks a solution via singular value decomposition as a fallback. We show that
the adaptive solver leads to notable speedups, while also freeing the user from
using direct calls to cumbersome LAPACK functions
- …